using System;
using System.IO;

using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Utilities.IO;

namespace Org.BouncyCastle.Bcpg
{
	/// <remarks>Reader for PGP objects.</remarks>
	public class BcpgInputStream
		: BaseInputStream
	{
		private Stream m_in;
		private bool next = false;
		private int nextB;

		internal static BcpgInputStream Wrap(
			Stream inStr)
		{
			if (inStr is BcpgInputStream)
			{
				return (BcpgInputStream) inStr;
			}

			return new BcpgInputStream(inStr);
		}

		private BcpgInputStream(
			Stream inputStream)
		{
			this.m_in = inputStream;
		}

		public override int ReadByte()
		{
			if (next)
			{
				next = false;
				return nextB;
			}

			return m_in.ReadByte();
		}

		public override int Read(
			byte[]	buffer,
			int		offset,
			int		count)
		{
			// Strangely, when count == 0, we should still attempt to read a byte
//			if (count == 0)
//				return 0;

			if (!next)
				return m_in.Read(buffer, offset, count);

			// We have next byte waiting, so return it

			if (nextB < 0)
				return 0; // EndOfStream

			if (buffer == null)
				throw new ArgumentNullException("buffer");

			buffer[offset] = (byte) nextB;
			next = false;

			return 1;
		}

		public byte[] ReadAll()
		{
			return Streams.ReadAll(this);
		}

		public void ReadFully(
			byte[]	buffer,
			int		off,
			int		len)
		{
			if (Streams.ReadFully(this, buffer, off, len) < len)
				throw new EndOfStreamException();
		}

		public void ReadFully(
			byte[] buffer)
		{
			ReadFully(buffer, 0, buffer.Length);
		}

		/// <summary>Returns the next packet tag in the stream.</summary>
		public PacketTag NextPacketTag()
		{
			if (!next)
			{
				try
				{
					nextB = m_in.ReadByte();
				}
				catch (EndOfStreamException)
				{
					nextB = -1;
				}

				next = true;
			}

			if (nextB >= 0)
			{
				if ((nextB & 0x40) != 0)    // new
				{
					return (PacketTag)(nextB & 0x3f);
				}
				else    // old
				{
					return (PacketTag)((nextB & 0x3f) >> 2);
				}
			}

			return (PacketTag) nextB;
		}

		public Packet ReadPacket()
		{
			int hdr = this.ReadByte();

			if (hdr < 0)
			{
				return null;
			}

			if ((hdr & 0x80) == 0)
			{
				throw new IOException("invalid header encountered");
			}

			bool newPacket = (hdr & 0x40) != 0;
			PacketTag tag = 0;
			int bodyLen = 0;
			bool partial = false;

			if (newPacket)
			{
				tag = (PacketTag)(hdr & 0x3f);

				int l = this.ReadByte();

				if (l < 192)
				{
					bodyLen = l;
				}
				else if (l <= 223)
				{
					int b = m_in.ReadByte();
					bodyLen = ((l - 192) << 8) + (b) + 192;
				}
				else if (l == 255)
				{
					bodyLen = (m_in.ReadByte() << 24) | (m_in.ReadByte() << 16)
						|  (m_in.ReadByte() << 8)  | m_in.ReadByte();
				}
				else
				{
					partial = true;
					bodyLen = 1 << (l & 0x1f);
				}
			}
			else
			{
				int lengthType = hdr & 0x3;

				tag = (PacketTag)((hdr & 0x3f) >> 2);

				switch (lengthType)
				{
					case 0:
						bodyLen = this.ReadByte();
						break;
					case 1:
						bodyLen = (this.ReadByte() << 8) | this.ReadByte();
						break;
					case 2:
						bodyLen = (this.ReadByte() << 24) | (this.ReadByte() << 16)
							| (this.ReadByte() << 8) | this.ReadByte();
						break;
					case 3:
						partial = true;
						break;
					default:
						throw new IOException("unknown length type encountered");
				}
			}

			BcpgInputStream objStream;
			if (bodyLen == 0 && partial)
			{
				objStream = this;
			}
			else
			{
				PartialInputStream pis = new PartialInputStream(this, partial, bodyLen);
				objStream = new BcpgInputStream(pis);
			}

			switch (tag)
			{
				case PacketTag.Reserved:
					return new InputStreamPacket(objStream);
				case PacketTag.PublicKeyEncryptedSession:
					return new PublicKeyEncSessionPacket(objStream);
				case PacketTag.Signature:
					return new SignaturePacket(objStream);
				case PacketTag.SymmetricKeyEncryptedSessionKey:
					return new SymmetricKeyEncSessionPacket(objStream);
				case PacketTag.OnePassSignature:
					return new OnePassSignaturePacket(objStream);
				case PacketTag.SecretKey:
					return new SecretKeyPacket(objStream);
				case PacketTag.PublicKey:
					return new PublicKeyPacket(objStream);
				case PacketTag.SecretSubkey:
					return new SecretSubkeyPacket(objStream);
				case PacketTag.CompressedData:
					return new CompressedDataPacket(objStream);
				case PacketTag.SymmetricKeyEncrypted:
					return new SymmetricEncDataPacket(objStream);
				case PacketTag.Marker:
					return new MarkerPacket(objStream);
				case PacketTag.LiteralData:
					return new LiteralDataPacket(objStream);
				case PacketTag.Trust:
					return new TrustPacket(objStream);
				case PacketTag.UserId:
					return new UserIdPacket(objStream);
				case PacketTag.UserAttribute:
					return new UserAttributePacket(objStream);
				case PacketTag.PublicSubkey:
					return new PublicSubkeyPacket(objStream);
				case PacketTag.SymmetricEncryptedIntegrityProtected:
					return new SymmetricEncIntegrityPacket(objStream);
				case PacketTag.ModificationDetectionCode:
					return new ModDetectionCodePacket(objStream);
				case PacketTag.Experimental1:
				case PacketTag.Experimental2:
				case PacketTag.Experimental3:
				case PacketTag.Experimental4:
					return new ExperimentalPacket(tag, objStream);
				default:
					throw new IOException("unknown packet type encountered: " + tag);
			}
		}

		public override void Close()
		{
			m_in.Close();
			base.Close();
		}

		/// <summary>
		/// A stream that overlays our input stream, allowing the user to only read a segment of it.
		/// NB: dataLength will be negative if the segment length is in the upper range above 2**31.
		/// </summary>
		private class PartialInputStream
			: BaseInputStream
		{
			private BcpgInputStream m_in;
			private bool partial;
			private int dataLength;

			internal PartialInputStream(
				BcpgInputStream	bcpgIn,
				bool			partial,
				int				dataLength)
			{
				this.m_in = bcpgIn;
				this.partial = partial;
				this.dataLength = dataLength;
			}

			public override int ReadByte()
			{
				do
				{
					if (dataLength != 0)
					{
						int ch = m_in.ReadByte();
						if (ch < 0)
						{
							throw new EndOfStreamException("Premature end of stream in PartialInputStream");
						}
						dataLength--;
						return ch;
					}
				}
				while (partial && ReadPartialDataLength() >= 0);

				return -1;
			}

			public override int Read(byte[] buffer, int offset, int count)
			{
				do
				{
					if (dataLength != 0)
					{
						int readLen = (dataLength > count || dataLength < 0) ? count : dataLength;
						int len = m_in.Read(buffer, offset, readLen);
						if (len < 1)
						{
							throw new EndOfStreamException("Premature end of stream in PartialInputStream");
						}
						dataLength -= len;
						return len;
					}
				}
				while (partial && ReadPartialDataLength() >= 0);

				return 0;
			}

			private int ReadPartialDataLength()
			{
				int l = m_in.ReadByte();

				if (l < 0)
				{
					return -1;
				}

				partial = false;

				if (l < 192)
				{
					dataLength = l;
				}
				else if (l <= 223)
				{
					dataLength = ((l - 192) << 8) + (m_in.ReadByte()) + 192;
				}
				else if (l == 255)
				{
					dataLength = (m_in.ReadByte() << 24) | (m_in.ReadByte() << 16)
						|  (m_in.ReadByte() << 8)  | m_in.ReadByte();
				}
				else
				{
					partial = true;
					dataLength = 1 << (l & 0x1f);
				}

				return 0;
			}
		}
	}
}
